/**
 * 前端数据存储工具类
 * 纯本地JSON存储，无需网络
 */
class StorageManager {
  constructor() {
    this.storageKeys = {
      USER_INFO: 'userInfo',
      RACE_LIST: 'raceList',
      SIGNUP_LIST: 'signupList',
      SETTINGS: 'settings'
    };
  }

  /**
   * 保存数据到本地存储
   * @param {string} key 存储键名
   * @param {any} data 要存储的数据
   */
  setLocalData(key, data) {
    try {
      const jsonData = JSON.stringify(data);
      wx.setStorageSync(key, jsonData);
      console.log(`[Storage] 数据已保存到本地: ${key}`);
    } catch (error) {
      console.error(`[Storage] 保存数据失败: ${key}`, error);
    }
  }

  /**
   * 从本地存储获取数据
   * @param {string} key 存储键名
   * @param {any} defaultValue 默认值
   * @returns {any} 存储的数据
   */
  getLocalData(key, defaultValue = null) {
    try {
      const jsonData = wx.getStorageSync(key);
      if (jsonData) {
        return JSON.parse(jsonData);
      }
      return defaultValue;
    } catch (error) {
      console.error(`[Storage] 获取数据失败: ${key}`, error);
      return defaultValue;
    }
  }

  /**
   * 删除本地存储的数据
   * @param {string} key 存储键名
   */
  removeLocalData(key) {
    try {
      wx.removeStorageSync(key);
      console.log(`[Storage] 数据已删除: ${key}`);
    } catch (error) {
      console.error(`[Storage] 删除数据失败: ${key}`, error);
    }
  }

  /**
   * 清空所有本地数据
   */
  clearAllData() {
    try {
      wx.clearStorageSync();
      console.log('[Storage] 所有本地数据已清空');
    } catch (error) {
      console.error('[Storage] 清空数据失败', error);
    }
  }

  /**
   * 获取存储信息
   * @returns {object} 存储信息
   */
  getStorageInfo() {
    try {
      return wx.getStorageInfoSync();
    } catch (error) {
      console.error('[Storage] 获取存储信息失败', error);
      return {};
    }
  }

  /**
   * 导出数据为JSON字符串
   * @param {string} key 数据键名
   * @returns {string} JSON字符串
   */
  exportDataAsJSON(key) {
    try {
      const data = this.getLocalData(key);
      return JSON.stringify(data, null, 2);
    } catch (error) {
      console.error(`[Storage] 导出数据失败: ${key}`, error);
      return null;
    }
  }

  /**
   * 从JSON字符串导入数据
   * @param {string} key 数据键名
   * @param {string} jsonString JSON字符串
   * @returns {boolean} 是否成功
   */
  importDataFromJSON(key, jsonString) {
    try {
      const data = JSON.parse(jsonString);
      this.setLocalData(key, data);
      console.log(`[Storage] 数据导入成功: ${key}`);
      return true;
    } catch (error) {
      console.error(`[Storage] 导入数据失败: ${key}`, error);
      return false;
    }
  }

  /**
   * 获取所有数据的统计信息
   * @returns {object} 统计信息
   */
  getDataStats() {
    try {
      const stats = {};
      const keys = ['userInfo', 'raceList', 'signupList', 'settings'];
      
      keys.forEach(key => {
        const data = this.getLocalData(key);
        if (Array.isArray(data)) {
          stats[key] = data.length;
        } else if (data) {
          stats[key] = 1;
        } else {
          stats[key] = 0;
        }
      });
      
      return stats;
    } catch (error) {
      console.error('[Storage] 获取统计信息失败', error);
      return {};
    }
  }

  /**
   * 检查存储空间使用情况
   * @returns {object} 存储使用情况
   */
  checkStorageUsage() {
    try {
      const storageInfo = this.getStorageInfo();
      const stats = this.getDataStats();
      
      return {
        currentSize: storageInfo.currentSize || 0,
        limitSize: storageInfo.limitSize || 10240, // 10MB
        usagePercent: ((storageInfo.currentSize || 0) / (storageInfo.limitSize || 10240)) * 100,
        dataStats: stats
      };
    } catch (error) {
      console.error('[Storage] 检查存储使用情况失败', error);
      return {};
    }
  }

  /**
   * 清理过期数据
   * @param {number} daysToKeep 保留天数
   */
  cleanupOldData(daysToKeep = 30) {
    try {
      const now = new Date().getTime();
      const cutoffTime = now - (daysToKeep * 24 * 60 * 60 * 1000);
      
      // 清理过期的比赛数据
      const raceList = this.getLocalData('raceList', []);
      const filteredRaces = raceList.filter(race => {
        const raceTime = new Date(race.createdAt).getTime();
        return raceTime > cutoffTime;
      });
      
      if (filteredRaces.length !== raceList.length) {
        this.setLocalData('raceList', filteredRaces);
        console.log(`[Storage] 清理了 ${raceList.length - filteredRaces.length} 条过期比赛数据`);
      }
      
      // 清理过期的报名数据
      const signupList = this.getLocalData('signupList', []);
      const filteredSignups = signupList.filter(signup => {
        const signupTime = new Date(signup.createTime).getTime();
        return signupTime > cutoffTime;
      });
      
      if (filteredSignups.length !== signupList.length) {
        this.setLocalData('signupList', filteredSignups);
        console.log(`[Storage] 清理了 ${signupList.length - filteredSignups.length} 条过期报名数据`);
      }
      
    } catch (error) {
      console.error('[Storage] 清理过期数据失败', error);
    }
  }
}

// 创建单例实例
const storageManager = new StorageManager();

module.exports = storageManager;